Chess

Bendra apžvalga

import pandas as pd
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
import seaborn as sns
from matplotlib.pyplot import figure

chess = pd.read_csv('C:\\Users\\Viktorija\\Desktop\\Duomenų analitika\\Atsiskaitomasis darbas\\chess_games.csv', index_col=0)
chess.head(2)

	rated	turns	victory_status	winner	time_increment	white_id	white_rating	black_id	black_rating	moves	opening_code	opening_moves	opening_fullname	opening_shortname	opening_response	opening_variation
game_id
1	False	13	Out of Time	White	15+2	bourgris	1500	a-00	1191	d4 d5 c4 c6 cxd5 e6 dxe6 fxe6 Nf3 Bb4+ Nc3 Ba5...	D10	5	Slav Defense: Exchange Variation	Slav Defense	NaN	Exchange Variation
2	True	16	Resign	Black	5+10	a-00	1322	skinnerua	1261	d4 Nc6 e4 e5 f4 f6 dxe5 fxe5 fxe5 Nxe5 Qd4 Nc6...	B00	4	Nimzowitsch Defense: Kennedy Variation	Nimzowitsch Defense	NaN	Kennedy Variation

chess.shape 

(20058, 16)

print(f"Viso nagrinėjama buvo {chess.shape[1]} stulpelių ir {chess.shape[0]} eilutės")
print (f"Duomenų bazę sudaro viso {chess.shape[0]} tarpusavyje sužaistos partijos.")

Viso nagrinėjama buvo 16 stulpelių ir 20058 eilutės
Duomenų bazę sudaro viso 20058 tarpusavyje sužaistos partijos.

print(chess.dtypes) 
# stulpelių tipai

rated                  bool
turns                 int64
victory_status       object
winner               object
time_increment       object
white_id             object
white_rating          int64
black_id             object
black_rating          int64
moves                object
opening_code         object
opening_moves         int64
opening_fullname     object
opening_shortname    object
opening_response     object
opening_variation    object
dtype: object

chess.describe().round(2)

	turns	white_rating	black_rating	opening_moves
count	20058.00	20058.00	20058.00	20058.00
mean	60.47	1596.63	1588.83	4.82
std	33.57	291.25	291.04	2.80
min	1.00	784.00	789.00	1.00
25%	37.00	1398.00	1391.00	3.00
50%	55.00	1567.00	1562.00	4.00
75%	79.00	1793.00	1784.00	6.00
max	349.00	2700.00	2723.00	28.00

#Ėjimų vidurkis - 60,47; vidutinis baltūjų reitingas - 1596,63; juodųjų - 1588,83, mažiausias reitingas - 784 

winner=pd.DataFrame(chess['winner']).value_counts().reset_index()
winner.rename(columns={ 0: 'kiekis'}, inplace=True) 
winner

	winner	kiekis
0	White	10001
1	Black	9107
2	Draw	950

winn=pd.DataFrame(chess['winner']).value_counts()
winn
winn.plot.pie(y='kiekis', title='Laimėjimų pasiskirstymas', autopct='%.2f%%', colors = ['blue', 'red', 'yellow'], figsize=(15,6), fontsize=15)

<AxesSubplot:title={'center':'Laimėjimų pasiskirstymas'}, ylabel='None'>

 # viso partijų - 20058, baltieji laimėjo 10001, juodieji - 9107, lygiosios 950 
 # atitinkamai pasiskirstė procentais: 49,86 %, 45,4% ir 4,74 %

# Daugiau partijų  laimėjo žaidę baltaisiais - 49,86 proc. palyginus su juodaisiais – 45,40 proc. 

### Daugiausiai partijų baigiasi vienai ar kitai pusei paskelbus matą. 

# pasiektų pergaliu pasiskirstymas. Skaičiuojant pergales, eliminuojama partijos, kurios buvo sužaistos lygiosiomis

winner_method = (pd.DataFrame(chess[['winner', 'victory_status']].value_counts())
                     .reset_index())
winner_method = winner_method[~(winner_method['winner'] == 'Draw')]
winner_method.rename(columns={ 0: 'kiekis'}, inplace=True)
winner_method

	winner	victory_status	kiekis
0	White	Resign	5844
1	Black	Resign	5303
2	White	Mate	3344
3	Black	Mate	2981
5	Black	Out of Time	823
6	White	Out of Time	813

# Daugiausiai partijų baigėsi, kai žaidėjai tiesio pasiduodavo.

### H3 Žaidėjų pasiskirstymas pagal reitingą.

# vidurkis
reitingas_mean=['white_rating', 'black_rating']
for i in reitingas_mean:
    mean = round(chess[i].mean(),2)
    print(mean)

1596.63
1588.83

raiting_values = chess.groupby('winner')[['white_rating', 'black_rating']].agg([min, max])
raiting_values

	white_rating		black_rating
	min	max	min	max
winner
Black	784	2621	789	2621
Draw	907	2524	869	2526
White	784	2700	795	2723

# Didžiausias ir mažiausias reitingas buvęs tarp skirtingų spalvų

# Žaidėjų pasiskirstymas pagal reitingą. 
# vidutinis juodųjų ir baltųjų reitingas kai laimėjo, kai pralošė, kai lygiosios
# koks buvo baltųjų vidurkis, kai laimėjo, bendras reitingas
# koks juodųjų vidurkis

reitingas=pd.DataFrame(chess.groupby('winner')['black_rating','white_rating'].mean()).reset_index().round(2)
reitingas

<ipython-input-121-eae33ec7170c>:1: FutureWarning: Indexing with multiple keys (implicitly converted to a tuple of keys) will be deprecated, use a list instead.
  reitingas=pd.DataFrame(chess.groupby('winner')['black_rating','white_rating'].mean()).reset_index().round(2)

	winner	black_rating	white_rating
0	Black	1638.23	1549.25
1	Draw	1641.21	1655.56
2	White	1538.88	1634.18

reitingas.plot(x='winner', y=['black_rating', 'white_rating'], kind='bar', title='Juodųjų ir baltųjų reitingas')

<AxesSubplot:title={'center':'Juodųjų ir baltųjų reitingas'}, xlabel='winner'>

Baltųjų reitingas, kai jie laimi prieš juoduosius yra žemesnis (1634,18), negu juodųjų reitingas, kai jie laimi prie baltuosius (1638,23).

Atitinkamai baltieji susiduria su mažesnį reitingą turinčiu žaidėju (1538,88), palyginus su juodaisiais. Jiems reikia laimėti prieš aukštesnį reitingą turintį žaidėją (1549,25).

Juodieji turi turėti aukštesnį reitingą, tada tikimybė laimėti didesnė.

Lygiosiomis baigiasi, kai susiduria panašų reitingą turintys vartotojai.

Žaidėjai yra linkę rinktis ilgesnio formato partijas

# populiariausia žaista forma(naudojamas žaidimui laikas). 

print(chess['time_increment'].value_counts().idxmax(10))

10+0

time = (pd.DataFrame(chess['time_increment'].value_counts()).reset_index())
time.rename(columns={'index':'laikas', 'time_increment':'zaista_kartu'}, inplace=True)
time.head(10)

	laikas	zaista_kartu
0	10+0	7721
1	15+0	1311
2	15+15	850
3	5+5	738
4	5+8	697
5	8+0	588
6	10+5	579
7	15+10	461
8	20+0	448
9	30+0	375

print(chess['time_increment'].value_counts().idxmax(10))

10+0

# Pirmasis skaičius nurodo laiką minutėmis, kiek buvo nustatyta pradžioje. 
# Antrasis skaičius nurodomas sekundėmis, kuris prisideda po kiekvieno atlikto važiavimo
# Išskaidomas stulpelis, kad sužinoti, koks pasirinktas laikas populiariausias
# Stulpelis padaromas stringu, kad būtų galima išskaidyti

chess['time_increment']. astype(str)
# string1 = chess['time_increment']
# num1
# # concatenated string 
# concatString = string1 + str(num1)
# print(concatString)
chess['laikas']=chess['time_increment'].str.split('+', 1).str[0]
time2 = pd.DataFrame(chess['laikas'].value_counts()).reset_index()
time2.rename(columns={'index':'laikas', 'laikas':'zaista_kartu'}, inplace=True)
time2.head(5)
# populiariausia žaidimo forma tik minutėmis

	laikas	zaista_kartu
0	10	9456
1	15	3382
2	5	1795
3	20	936
4	8	924

# vidurkis
laikas_mean=['laikas']
for i in laikas_mean:
    mean = time2[i].mean()
    print(mean)

3.077335850684584e+56

Populiariausia forma, beveik pusė visų žaistų partijų buvo 10 min. greitosios partijos (nepriklausoma kokia variacija buvo naudojama vėliau).

Nors tai palyginus trumpas žaidimas, tačiau atsižvelgiant į vidurkį - 3,08, žaidėjai rinkosi ilgesnio formato partijas.

# sudedama aktuali informacija, kad būtų galima palyginti rodiklius

time3=pd.DataFrame(chess[[ 'laikas','time_increment','turns', 'white_rating', 'black_rating', 'winner', 'opening_shortname']])
time3

	laikas	time_increment	turns	white_rating	black_rating	winner	opening_shortname
game_id
1	15	15+2	13	1500	1191	White	Slav Defense
2	5	5+10	16	1322	1261	Black	Nimzowitsch Defense
3	5	5+10	61	1496	1500	White	King's Pawn Game
4	20	20+0	61	1439	1454	White	Queen's Pawn Game
5	30	30+3	95	1523	1469	White	Philidor Defense
...	...	...	...	...	...	...	...
20054	10	10+10	24	1691	1220	White	Dutch Defense
20055	10	10+0	82	1233	1196	Black	Queen's Pawn
20056	10	10+0	35	1219	1286	White	Queen's Pawn Game
20057	10	10+0	109	1360	1227	White	Pirc Defense
20058	10	10+0	78	1235	1339	Black	Queen's Pawn Game

20058 rows × 7 columns

sns.scatterplot(data=time3, x='time_increment', y='white_rating', hue='turns') 
# kuo mažesnis laikas, tuo daugiau atliekama judesių

<AxesSubplot:xlabel='time_increment', ylabel='white_rating'>

# atliktų važiavimų skaičius nepriklauso nuo nieko. Duomenys labiau susitelkę ties mažesnės trukmės žaidimo variantais.
# Ilgesnes partijas renkasi daugiau vidutinį reitingą turintys žaidėjai. 

# žaidėjų pasiskirstymas 
# Kuri spalva laimėjos, atsižvelgiant į baltųjų ir juodųjų reitingus tuo metu, ir ėjimų pasiskirstymą;

sns.pairplot(time3, hue='winner') 

<seaborn.axisgrid.PairGrid at 0x1d97793ebe0>

# Tendencija ta, kad aukštesnį reitingą turintis žaidėjas laimi, nepriklausomai kokia spalva pradeda. 
# Lygiosios daugiau įvyksta, kai ėjimų skaičius yra didesnis;
# Daugiausiai ėjimų iš nagrinėjamos bazės buvo atlikta, kada laimėjo baltieji.
# Nėra priklausomybės, kad atlikus daugiau ėjimų laimės viena ar kita pusė. 
# Juodieji, kai jų reitingas yra žemesnis, laimi prieš baltuosius, kai reitingas yra iki ~1400.

#juodųjų reitingas/laikas/laimėjimas

sns.scatterplot(data=time3, x='time_increment', y='black_rating', hue='winner', palette=['yellow','dodgerblue','red']) 

<AxesSubplot:xlabel='time_increment', ylabel='black_rating'>

# Juodieji, turintys žemesnį reitingą, laimi dažniau. Esant aukštesniam juodųjų reitingui, dažniau laimi baltieji. 
# Laiko pasirinkimas įtakos neturi

sns.scatterplot(data=time3, x='time_increment', y='white_rating', hue='winner', palette=['yellow','dodgerblue','red']) 

<AxesSubplot:xlabel='time_increment', ylabel='white_rating'>

# Reitingų pasiskirstymas

sns.boxplot(x='winner', y='white_rating', data=time3, color='red', linewidth=2)
sns.boxplot(x='winner', y='black_rating', data=time3, color='blue', linewidth=2)

<AxesSubplot:xlabel='winner', ylabel='black_rating'>

# skirtumas tarp baltųjų ir juodųjų reitingo, priklausomai kas pasiekia pergalę. 
# Lygiosiomis sužaidžia aukštesnį reitingą turintys žaidėjai

chess[['white_rating','black_rating']].describe() 

	white_rating	black_rating
count	20058.000000	20058.000000
mean	1596.631868	1588.831987
std	291.253376	291.036126
min	784.000000	789.000000
25%	1398.000000	1391.000000
50%	1567.000000	1562.000000
75%	1793.000000	1784.000000
max	2700.000000	2723.000000

Ėjimų psiskirstymas.

sns.countplot(x='turns', data=time3)

<AxesSubplot:xlabel='turns', ylabel='count'>

# ėjimų skaičius ir kiek kartų buvo tokių partijų

sns.boxplot(x='turns', data=time3, color='red', linewidth=2)

<AxesSubplot:xlabel='turns'>

chess['turns'].describe() 

count    20058.000000
mean        60.465999
std         33.570585
min          1.000000
25%         37.000000
50%         55.000000
75%         79.000000
max        349.000000
Name: turns, dtype: float64

# Pusė partijų buvo sužaista, kada ėjimų skaičius svyravo nuo 37 iki 79.
# Ėjimai pasiskirstę sąlyginai mažai. 

#kiek ėjimų yra per partiją
chess.reset_index()
turns=pd.DataFrame(chess.groupby('turns')['game_id'].count().sort_values(ascending=False))
turns.rename(columns={'game_id':'kartai'}, inplace=True)
turns

	kartai
turns
53	303
45	302
51	299
57	297
39	297
...	...
193	1
176	1
187	1
184	1
204	1

211 rows × 1 columns

sns.displot(turns['kartai'], color = 'red') 

<seaborn.axisgrid.FacetGrid at 0x202ebea4340>

# partijų pasiskirstymas pagal atliktų judesių skaičių ir kiek tokių partijų buvo sužaista
# pasitikriname, kiek daugiausiai kartų atlikta (populiariusias) ėjimų skaičius. 
# Daugiausiai atlikta kartų -53 ėjimų buvo 303 partijose, 45 ėjimai 302 partijose ir t.t.

# Kaip pasiskirsto ėjimų skaičius partijose pagal laiką

sns.jointplot(x='time_increment', y='turns', data=time3, color='orange') 

<seaborn.axisgrid.JointGrid at 0x202e94a1b20>

Didejant pasirinktam laikui, mažėja važiavimų skaičius; kuo mažesnis laikas, tuo daugiau judesių.

Vidutiniškai buvo atlikta 60 ėjimų.

Didėjant ėjimų skaičiui žaistų partijų mažėja.

Populiariausi opening variantai, kai laimėjo juodi ir kai laimėjo balti nesiskiria

# Populiariausi opening variantai, kokie buvo naudoti tarp visų

openings = pd.DataFrame(chess['opening_fullname'].value_counts().head(20))
openings.rename(columns={ 'index': 'opening_fullname', 'opening_fullname': 'naudota_kartu' }, inplace=True)
openings

	naudota_kartu
Van't Kruijs Opening	368
Sicilian Defense	358
Sicilian Defense: Bowdler Attack	296
French Defense: Knight Variation	271
Scotch Game	271
Scandinavian Defense: Mieses-Kotroc Variation	259
Queen's Pawn Game: Mason Attack	232
Queen's Pawn Game: Chigorin Variation	229
Scandinavian Defense	223
Horwitz Defense	209
Caro-Kann Defense	199
Philidor Defense #3	198
Philidor Defense #2	193
Indian Game	181
Italian Game: Anti-Fried Liver Defense	180
Four Knights Game: Italian Variation	176
Modern Defense	174
Owen Defense	168
King's Pawn Game: Wayward Queen Attack	164
Sicilian Defense: Old Sicilian	159

### Populiariausias naudotas opening variantas tarp visų žaidėjų: Van't Kruijs Opening (368 kartai), Sicilian Defense (358 kartai) ir Sicilian Defense: Bowdler Attack (296). 

# populiariausi opening variantai, kai balti laimėjo 

baltuju_laimejimas = chess[chess['winner']=='White']
white_openings = pd.DataFrame(baltuju_laimejimas['opening_fullname'].value_counts().head(20)).reset_index()
white_openings.rename(columns={ 'index': 'opening_fullname', 'opening_fullname': 'laimėta' }, inplace=True)
white_openings

	opening_fullname	laimėta
0	Scandinavian Defense: Mieses-Kotroc Variation	164
1	Sicilian Defense	149
2	Scotch Game	145
3	French Defense: Knight Variation	135
4	Philidor Defense #3	127
5	Van't Kruijs Opening	126
6	Sicilian Defense: Bowdler Attack	119
7	Queen's Pawn Game: Mason Attack	116
8	Queen's Pawn Game: Chigorin Variation	112
9	Horwitz Defense	110
10	Caro-Kann Defense	109
11	Italian Game: Anti-Fried Liver Defense	97
12	Four Knights Game: Italian Variation	95
13	Scandinavian Defense	90
14	Philidor Defense #2	89
15	Queen's Pawn	85
16	Philidor Defense	84
17	Queen's Gambit Refused: Marshall Defense	84
18	Modern Defense	81
19	Owen Defense	76

### Populiariausi opening variantai, kai balti laimėjo: Scandinavian Defense: Mieses-Kotroc Variation (164), Sicilian Defense (149) ir Scotch Game (145).

# populiariausi opening, kai laimi juodieji
juoduju_laimejimas = chess[chess['winner']=='Black']
black_openings = pd.DataFrame(juoduju_laimejimas['opening_fullname'].value_counts().head(20)).reset_index()
black_openings.rename(columns={ 'index': 'opening_fullname', 'opening_fullname': 'laimėta' }, inplace=True)
black_openings

	opening_fullname	laimėta
0	Van't Kruijs Opening	226
1	Sicilian Defense	194
2	Sicilian Defense: Bowdler Attack	164
3	Scandinavian Defense	123
4	French Defense: Knight Variation	121
5	Scotch Game	115
6	Queen's Pawn Game: Chigorin Variation	109
7	Queen's Pawn Game: Mason Attack	103
8	Indian Game	100
9	Philidor Defense #2	96
10	Horwitz Defense	94
11	Sicilian Defense: Old Sicilian	93
12	Scandinavian Defense: Mieses-Kotroc Variation	89
13	Modern Defense	87
14	King's Pawn Game: Wayward Queen Attack	84
15	Owen Defense	83
16	Queen's Pawn Game	83
17	Caro-Kann Defense	83
18	King's Pawn Game: Leonardis Variation	83
19	Four Knights Game: Italian Variation	74

### Populiariausi opening, kai laimi juodieji: Van't Kruijs Opening (226), Sicilian Defense (194) ir Sicilian Defense: Bowdler Attack (164).

# juodųjų ir baltųjų openings palyginimas

juodi_balti=pd.merge(white_openings, black_openings, on=['opening_fullname'], suffixes=( 'balti', 'juodi'))
juodi_balti.rename(columns={'laimėtabalti':'laimėta_baltais','laimėtajuodi':'laimėta_juodais' }, inplace=True)
juodi_balti

	opening_fullname	laimėta_baltais	laimėta_juodais
0	Scandinavian Defense: Mieses-Kotroc Variation	164	89
1	Sicilian Defense	149	194
2	Scotch Game	145	115
3	French Defense: Knight Variation	135	121
4	Van't Kruijs Opening	126	226
5	Sicilian Defense: Bowdler Attack	119	164
6	Queen's Pawn Game: Mason Attack	116	103
7	Queen's Pawn Game: Chigorin Variation	112	109
8	Horwitz Defense	110	94
9	Caro-Kann Defense	109	83
10	Four Knights Game: Italian Variation	95	74
11	Scandinavian Defense	90	123
12	Philidor Defense #2	89	96
13	Modern Defense	81	87
14	Owen Defense	76	83

Juodųjų ir baltųjų 3 populiariausi laimėti opening variantai nesutampa.

Trys populiariausi opening variantai, kai laimėjo balti neatitinka populiariausių bendrai naudotų opening variantų.

Juodųjų opening variantai atitinka populiariausius.

Unikalūs vartotojai ir unikalios partijos. Ar buvo žaista partijų tarpusavyje tarp tų pačių žaidėjų.

chess.white_id.unique().size
# nagrinėjama kiek yra unikalių baltų žaidėjų - 9438 (viso sužaista 20058 kartai)

9438

chess.black_id.unique().size
# unikalių juodų žaidėjų - 9331 (viso sužaista 20058 kartai)

9331

white_un=chess.white_id.unique().size
white_unique_percent=round(white_un/len(chess)*100, 2)
print(f"Baltų unikalių žaidėjų procentas tarp visų žaidėjų - {white_unique_percent}")
black_un=chess.black_id.unique().size
black_unique_percent=round(black_un/len(chess)*100, 2)
print(f"Juodų unikalių žaidėjų procentas tarp visų žaidėjų - {black_unique_percent}")    

Baltų unikalių žaidėjų procentas tarp visų žaidėjų - 47.05
Juodų unikalių žaidėjų procentas tarp visų žaidėjų - 46.52

# Baltaisiai žaidė daugiau unikalių vartotojų, juodieji nežymiai kartojosi daugiau

# Partijos tarp tų pačių žaidėjų

print(chess.loc[:, ['white_id','black_id']].value_counts().head(10)) 

white_id         black_id        
thebadfish       crraii              22
chiggen          drakon1             16
projetoxadrez    thebestofthebad     15
duckduckfrog     smartduckduckcow    15
zher0            shaeila89           14
thebestofthebad  projetoxadrez       14
enricolord       chesslearningpro    14
aaaaaaaddd       cfc52               13
lzchips          solidchess_hehe     13
ahmedgomez       mahmoud_safyan      13
dtype: int64

# 10 porų, kurios žaidė daugiausiai kartų tarpusavyje;
# Daugiausiai tarpusavyje žaidė žaidėjai -  thebadfish ir crraii – 22 kartai. 

neunikalios_partijos=pd.DataFrame(chess.loc[:, ['white_id','black_id']].value_counts())
neunikalios_partijos.rename(columns={0:'kartai'},inplace=True)
nenunikalus_kartai=neunikalios_partijos[neunikalios_partijos['kartai']>1].count()
print(f"Viso buvo sužaista pasikartojančių partijų tarpusavyje - {nenunikalus_kartai}") 

Viso buvo sužaista pasikartojančių partijų tarpusavyje - kartai    1529
dtype: int64

neunik_proc = round(nenunikalus_kartai/len(chess)*100,2)
neunik_proc
print(f"Pasikartojančių partijų procentas tarp visų žaistų - {neunik_proc}")

Pasikartojančių partijų procentas tarp visų žaistų - kartai    7.62
dtype: float64

Viso buvo unikalių baltųjų ID 9438 ir juodųjų ID 9331. Baltaisiai sužaidė daugiau skirtingų vartotojų 47.05 proc.

Tarp žaistų viso (20058) partijų neunikalių partijų, kai žaidė tarpusavyje tie patys žaidėjai buvo – 1529, kas sudarė 7,62 proc. visų žaistų partijų.

# Karalienės gambitas
karalienes_gambitas=chess['opening_shortname']=="Queen's Gambit"
karalienes_gambitas.value_counts()

False    19146
True       912
Name: opening_shortname, dtype: int64

gamb_proc=round(len(chess[chess['opening_shortname']=="Queen's Gambit"])/len(chess)*100,2)
print(f"Karalienės gambitą kaip opening naudojo - {gamb_proc} procentai visų žaidėjų")

Karalienės gambitą kaip opening naudojo - 4.55 procentai visų žaidėjų

Karalienės gambitą naudojo 912 opening situacijose, tai sudarė 4.55 proc. 

# priėmimas atmetimas

open_resp=pd.DataFrame(chess.groupby(['opening_shortname'])['opening_response'].value_counts())
open_resp

		opening_response
opening_shortname	opening_response
Benko Gambit	Accepted	8
	Declined	3
Blackmar-Diemer Gambit	Declined	5
Blumenfeld Countergambit	Accepted	4
Center Game	Accepted	2
Danish Gambit	Accepted	40
	Declined	4
Englund Gambit	Declined	42
Englund Gambit Complex	Declined	4
King's Gambit	Accepted	133
	Declined	51
Latvian Gambit	Accepted	13
Queen's Gambit	Declined	394
	Accepted	253
	Refused	251

# kiek atmetus/priėmus buvo laimėta/pralošta
karal=chess.loc[
    (chess['winner']=='White') 
    & 
    (chess['opening_shortname']=="Queen's Gambit")
     & 
    (chess['opening_response']=="Accepted"),
['winner']]
karal.value_counts().reset_index()

	winner	0
0	White	139

karalb=chess.loc[
    (chess['winner']=='Black') 
    & 
    (chess['opening_shortname']=="Queen's Gambit")
     & 
    (chess['opening_response']=="Accepted"),
['winner']]
karalb.value_counts().reset_index()

	winner	0
0	Black	105

# juodiesiems nepalanku priimti

karal2=chess.loc[
    (chess['winner']=='White') 
    & 
    (chess['opening_shortname']=="Queen's Gambit")
     & 
    (chess['opening_response']=="Declined"),
['winner']]
karal2.value_counts().reset_index()

	winner	0
0	White	211

karalb2=chess.loc[
    (chess['winner']=='Black') 
    & 
    (chess['opening_shortname']=="Queen's Gambit")
     & 
    (chess['opening_response']=="Declined"),
['winner']]
karalb2.value_counts().reset_index()

	winner	0
0	Black	165

karal3=chess.loc[
    (chess['winner']=='White') 
    & 
    (chess['opening_shortname']=="Queen's Gambit")
     & 
    (chess['opening_response']=="Refused"),
['winner']]
karal3.value_counts().reset_index()

	winner	0
0	White	152

karalb3=chess.loc[
    (chess['winner']=='Black') 
    & 
    (chess['opening_shortname']=="Queen's Gambit")
     & 
    (chess['opening_response']=="Refused"),
['winner']]
karalb3.value_counts().reset_index()

	winner	0
0	Black	91

# nepalankus metodas aplamai 

Populiariausias žaidėjas. Populiariausio žaidėjo statistika atitinka bendrą visų žaistų partijų statistiką

# Populiariausias žaidėjas, tarp visų žaidusių baltaisiais ir juodaisiai 

chess['white_id'].describe() 

count       20058
unique       9438
top       taranga
freq           72
Name: white_id, dtype: object

chess['black_id'].describe() 

count       20058
unique       9331
top       taranga
freq           82
Name: black_id, dtype: object

# baltaisiais žaidė 9438 skirtingi vartotojai, populiariausias žaidėjas - taranga, žaista 72 kartai baltaisiais 
# juodaisiais žaidė 9331 skirtingi vartotojai, populiariausias žaidėjas - taranga, žaista 82 kartai juodaisiais

white_pop=chess['white_id'].value_counts().max()  
print(f"Viso buvo sužaista baltaisiais- {white_pop} kartai") 
black_pop=chess['black_id'].value_counts().max() 
print(f"Viso buvo sužaista juodaisiais - {black_pop} kartai")

Viso buvo sužaista baltaisiais- 72 kartai
Viso buvo sužaista juodaisiais - 82 kartai

#viso žaista populiariausio baltaisias 72 kartai
# viso žaista populiariausio juodaisiai 82 kartai

# daugiausiai kartų laimėjęs žaidėjas juodaisias ir baltaisiais

white_winn=chess[chess['winner']=='White']
max_winn=pd.DataFrame(white_winn['white_id'].value_counts())
max_winn.head(5)

	white_id
taranga	34
ssf7	29
hassan1365416	28
a_p_t_e_m_u_u	25
1240100948	22

black_winn=chess[chess['winner']=='Black']
max_winn=pd.DataFrame(black_winn['black_id'].value_counts())
max_winn.head(5)

	black_id
taranga	38
ducksandcats	29
vladimir-kramnik-1	28
chesscarl	27
docboss	25

# Daugiausiai baltaisiai laimėjo taranga - 34 kartai
# Daugiausiai juodaisiais laimėjo taranga - 38 kartai
# Populiariausias ir dugiausiai laimėjęs žaidėjas šiuo atveju sutampa

# kiek buvo laimėta juodaisiais ir baltaisiais konkretaus žaidėjo. 

pop_white=chess.loc[
    (chess['winner']=='White') 
    & 
    (chess['white_id']=='taranga'),
    ['white_id', 'winner']]
pop_white.value_counts().reset_index()

	white_id	winner	0
0	taranga	White	34

pop_black=chess.loc[
    (chess['winner']=='Black') 
    & 
    (chess['black_id']=='taranga'),
    ['black_id', 'winner']]
pop_black.value_counts().reset_index()

	black_id	winner	0
0	taranga	Black	38

# iš žaistų 72 baltaisiais, laimėjo 34 kartus
# iš žaistų 82 juodaisiais, laimėjo 38 kartus 

# kiek jis kartų laimėjo ir kiek pralošė procentais

white_proc=round(pop_white.value_counts()/white_pop*100,2)
print(f"Laimėjimų procentas baltaisiais- {white_proc} ") 
black_proc=round(pop_black.value_counts()/black_pop*100,2)
print(f"Laimėjimų procentas juodaisias- {black_proc} ") 

Laimėjimų procentas baltaisiais- white_id  winner
taranga   White     47.22
dtype: float64 
Laimėjimų procentas juodaisias- black_id  winner
taranga   Black     46.34
dtype: float64 

# populiariausias žaidėjas iš žaistų viso 72 baltaisiais partijų, laimėjo 34 kartus
# populiariausias žaidėjas iš žaistų viso 82 juodaisiais partijų, laimėjo 38 kartus 
# baltųjų laimėjimo procentas - 47,22 proc.
# juodųjų laimėjimo procentas - 46,34 proc.

# populiariausio žaidėjo naudotas opening, kai laimėjo žaisdamas baltais ir juodais 

pop_open_white = chess[(chess['winner']=='White')& (chess['white_id']=='taranga')]
pop_taranga=pd.DataFrame(pop_open_white['opening_shortname'].value_counts())
pop_taranga.rename(columns={0:'opening_shortname', 'opening_shortname': "opening_kiekis"}, inplace=True)
pop_taranga

	opening_kiekis
Philidor Defense	8
Ruy Lopez	6
Scandinavian Defense	4
Italian Game	4
Caro-Kann Defense	4
Alekhine Defense	3
King's Pawn Game	3
Russian Game	1
French Defense	1

pop_open_black = chess[(chess['winner']=='Black')& (chess['black_id']=='taranga')]
pop_taranga2=pd.DataFrame(pop_open_black['opening_shortname'].value_counts())
pop_taranga2.rename(columns={'opening_shortname': "opening_kiekis"}, inplace=True)
pop_taranga2

	opening_kiekis
Four Knights Game	7
King's Pawn Game	6
Englund Gambit	4
Hungarian Opening	4
Italian Game	4
Crab Opening	4
Scotch Game	4
Queen's Pawn Game	4
Queen's Gambit	1

# Minėto žaidėjo sėkmingiausias opening baltaisiais Philidor Defense, naudotas openink kai jis laimėjo juodaisiais - Four Knights Game

# patikrinama atvirkštinis variantas, kada žaidėjas pralošė žaisdamas juodaisiasi, sėkmingas baltųjų opening
# ir kai žaidė baltaisiais, tada juodieji laimėjo

# žaidė baltaisiais ir pralošė nesėkmingi opening. 

pop_open_white2 = chess[(chess['winner']=='Black')& (chess['white_id']=='taranga')]
nesekmingi_open=pd.DataFrame(pop_open_white2['opening_shortname'].value_counts())
nesekmingi_open.rename(columns={0:'opening_shortname', 'opening_shortname': "opening_kiekis"}, inplace=True)
print(nesekmingi_open)

                       opening_kiekis
Sicilian Defense                   10
Philidor Defense                    8
Ruy Lopez                           7
French Defense                      4
Giuoco Piano                        4
King's Knight Opening               3
Petrov's Defense                    1

Šis žaidėjas žaidžia tiksliau juodaisias (46,34 proc.,), nei bendrass vidurkis (45,40 proc), tačiau blogiau baltaisiais (46.34 proc. vs 49,86 %)

Kai laimėjo baltieji populiariausias opening - Philidor Defense (8) ir Ruy Lopez (6), kai laimėjo juodieji - Four Knights Game (7) ir King's Pawn Game (6).

Opening metodai nesutampa su populiariausiai visų naudotais opening.

Baltieji turėdami aukštesnį reitingą prieš juoduosiud laimi dažniau

# baltųjų laimėjimas su aukštesniu ir žemesniu reitingu 
# patikrinama kiek baltųjų laimėjo, turėdami aukštesnį reitingą

white_winn=chess[chess['winner']=='White']
white_proc_winn = round(len(white_winn[(white_winn['white_rating'])>
                                  (white_winn['black_rating'])
                                                             ])/len(white_winn)*100,2)
white_proc_winn

65.28

# baltųjų laimėjimas su žemesniu reitingu

white_winn=chess[chess['winner']=='White']
white_proc_los = round(len(white_winn[(white_winn['white_rating'])<
                                  (white_winn['black_rating'])
                                                             ])/len(white_winn)*100,2)
white_proc_los

33.77

# juodųjų laimėjimas su aukštesniu reitingu 

black_winn=chess[chess['winner']=='Black']
black_proc_winn = round(len(black_winn[(black_winn['black_rating']) >
                                  (black_winn['white_rating'])
                                                             ]) / len(black_winn) * 100,2)
black_proc_winn

63.94

# juodųjų laimėjimas su žemesniu reitingu

black_winn=chess[chess['winner']=='Black']
black_proc_los = round(len(black_winn[(black_winn['black_rating']) <
                                  (black_winn['white_rating'])
                                                             ]) / len(black_winn) * 100,2)
black_proc_los

35.02

print(white_proc_winn, 'baltųjų_laimėjimas_aukštesnis_reitingas')
print(white_proc_los, 'baltųjų_laimėjimas_žemesnis_reitingas')
print(black_proc_winn, 'juodųjų_laimėjimas_aukštesnis_reitingas')
print(black_proc_los, 'juodųjų_laimėjimas_žemesnis_reitingas')

65.28 baltųjų_laimėjimas_aukštesnis_reitingas
33.77 baltųjų_laimėjimas_žemesnis_reitingas
63.94 juodųjų_laimėjimas_aukštesnis_reitingas
35.02 juodųjų_laimėjimas_žemesnis_reitingas

Baltųjų žaidėjai, turėdami aukštesnį reitingą prieš varžovą, laimėjo 65.28 proc., o juodieji 63.94 proc. partijų.

Baltieji turėdami žemesnį reitingą laimėjo 33.77proc.,o juodieji su žemesniu laimėjo 35,02 proc.

Juodieji, turėdami žemesnį reitingą laimi dažniau, nei baltieji, turėdami žemesnį reitingą.

Kiek baltųjų reitingas turi būti aukštesnis, kad jie laimėtų; kiek juodųjų reitingas turi būti aukštesnis, kad laimėtų.

# kiek baltųjų reitingas turi skirtis prieš juodus, kad jie laimėtų 

chess.head(1)

	rated	turns	victory_status	winner	time_increment	white_id	white_rating	black_id	black_rating	moves	opening_code	opening_moves	opening_fullname	opening_shortname	opening_response	opening_variation
game_id
1	False	13	Out of Time	White	15+2	bourgris	1500	a-00	1191	d4 d5 c4 c6 cxd5 e6 dxe6 fxe6 Nf3 Bb4+ Nc3 Ba5...	D10	5	Slav Defense: Exchange Variation	Slav Defense	NaN	Exchange Variation

import matplotlib
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
import numpy as np

from sklearn.linear_model import LogisticRegression
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split

# sklearn modulis logistinė regresija # baltųjų reitingas disesnis

chess['retingu_sirtumas_w_b']= chess['white_rating']-chess['black_rating']
X = chess[['retingu_sirtumas_w_b']]
X

	retingu_sirtumas_w_b
game_id
1	309
2	61
3	-4
4	-15
5	54
...	...
20054	471
20055	37
20056	-67
20057	133
20058	-104

20058 rows × 1 columns

chess['winner2']= (chess['winner'] == 'White').astype('int')
(chess['winner'] == 'White')
chess['winner2']
y=chess['winner2']
y

game_id
1        1
2        0
3        1
4        1
5        1
        ..
20054    1
20055    0
20056    1
20057    1
20058    0
Name: winner2, Length: 20058, dtype: int32

X = chess[['retingu_sirtumas_w_b']]
model = LogisticRegression()
model.fit(X, y)
chess['Prediction']=model.predict(X)
chess.head(1)

	rated	turns	victory_status	winner	time_increment	white_id	white_rating	black_id	black_rating	moves	opening_code	opening_moves	opening_fullname	opening_shortname	opening_response	opening_variation	retingu_sirtumas_w_b	winner2	Prediction
game_id
1	False	13	Out of Time	White	15+2	bourgris	1500	a-00	1191	d4 d5 c4 c6 cxd5 e6 dxe6 fxe6 Nf3 Bb4+ Nc3 Ba5...	D10	5	Slav Defense: Exchange Variation	Slav Defense	NaN	Exchange Variation	309	1	1

model.score(X,y) 

0.6449795592780936

model.predict([[9]])
# True yra 1
# False yra 0

array([0])

# sklearn modulis train-test-split # juodųjų reitingas didesnis

chess['retingu_sirtumas_b_w']= chess['black_rating']-chess['white_rating']
X = chess[['retingu_sirtumas_b_w']]
chess['winner3']= (chess['winner'] == 'Black').astype('int')
(chess['winner'] == 'Black')
chess['winner3']
y=chess['winner3']
y

game_id
1        0
2        1
3        0
4        0
5        0
        ..
20054    0
20055    1
20056    0
20057    0
20058    1
Name: winner3, Length: 20058, dtype: int32

train_test_split(X, y, test_size=0.3) 
X_test, X_train, y_test, y_train = train_test_split(X, y, test_size=0.3)
model = LogisticRegression()
model.fit(X_train, y_train) # apmokoma
y_predicted = model.predict(X_test)
model.score(X_test, y_test)

0.6548433048433049

model.predict([[45]]) 

array([1])

# True yra 1
# False yra 0

Baltųjų reitingas turi būti 9 vnt aukštesnis. Juodiesiems reikia turėti aukštesnį reitingą 45.